/**
 * 技能描述管理器
 * 负责生成和更新技能描述，确保描述与实际效果匹配
 */

import { ISkill, IBattleParticipant } from '../architecture/interfaces';
import { SkillType, TargetType } from '../../../shared/face/enums';
import BattleLogger from '../BattleLogger';

/**
 * 技能描述模板接口
 */
export interface ISkillDescriptionTemplate {
    /** 基础描述 */
    baseDescription: string;
    
    /** 等级描述模板 */
    levelTemplate?: string;
    
    /** 永久提升描述模板 */
    permanentBoostTemplate?: string;
    
    /** 效果描述模板 */
    effectTemplate?: string;
    
    /** 冷却描述模板 */
    cooldownTemplate?: string;
}

/**
 * 技能描述管理器
 */
export class SkillDescriptionManager {
    /** 描述模板缓存 */
    private descriptionTemplates: Map<string, ISkillDescriptionTemplate> = new Map();
    
    /** 描述变量解析器 */
    private variableResolvers: Map<string, (skill: ISkill, caster?: IBattleParticipant) => any> = new Map();

    constructor() {
        this.initializeVariableResolvers();
    }

    /**
     * 初始化变量解析器
     */
    private initializeVariableResolvers(): void {
        // 等级变量
        this.variableResolvers.set('{level}', (skill: ISkill) => skill.level);
        this.variableResolvers.set('{maxLevel}', (skill: ISkill) => skill.maxLevel);
        
        // 经验变量
        this.variableResolvers.set('{exp}', (skill: ISkill) => skill.exp);
        this.variableResolvers.set('{expNeeded}', (skill: ISkill) => skill.level * 100);
        
        // 使用次数变量
        this.variableResolvers.set('{useCount}', (skill: ISkill) => skill.useCount);
        
        // 冷却变量
        this.variableResolvers.set('{cooldown}', (skill: ISkill) => skill.cooldown);
        this.variableResolvers.set('{currentCooldown}', (skill: ISkill) => skill.currentCooldown);
        
        // 永久提升变量
        this.variableResolvers.set('{permanentBoosts}', (skill: ISkill) => {
            const boosts: string[] = [];
            for (const [boostType, amount] of skill.permanentBoosts) {
                boosts.push(`${boostType} +${amount}`);
            }
            return boosts.join(', ');
        });
        
        // 效果变量
        this.variableResolvers.set('{baseEffect}', (skill: ISkill, caster?: IBattleParticipant) => {
            return this.calculateBaseEffect(skill, caster);
        });
        
        this.variableResolvers.set('{levelEffect}', (skill: ISkill, caster?: IBattleParticipant) => {
            return this.calculateLevelEffect(skill, caster);
        });
        
        this.variableResolvers.set('{totalEffect}', (skill: ISkill, caster?: IBattleParticipant) => {
            return this.calculateTotalEffect(skill, caster);
        });
    }

    /**
     * 注册技能描述模板
     * @param skillId 技能ID
     * @param template 描述模板
     */
    public registerDescriptionTemplate(skillId: string, template: ISkillDescriptionTemplate): void {
        this.descriptionTemplates.set(skillId, template);
        BattleLogger.log('info', '技能描述模板注册成功', { skillId, template });
    }

    /**
     * 生成技能描述
     * @param skill 技能实例
     * @param caster 施法者（可选）
     * @returns 生成的描述
     */
    public generateDescription(skill: ISkill, caster?: IBattleParticipant): string {
        const template = this.descriptionTemplates.get(skill.id);
        if (!template) {
            return this.generateDefaultDescription(skill, caster);
        }

        let description = template.baseDescription;

        // 替换变量
        description = this.replaceVariables(description, skill, caster);

        // 添加等级信息
        if (template.levelTemplate && skill.level > 1) {
            const levelDesc = this.replaceVariables(template.levelTemplate, skill, caster);
            description += ` ${levelDesc}`;
        }

        // 添加永久提升信息
        if (template.permanentBoostTemplate && skill.permanentBoosts.size > 0) {
            const boostDesc = this.replaceVariables(template.permanentBoostTemplate, skill, caster);
            description += ` ${boostDesc}`;
        }

        // 添加效果信息
        if (template.effectTemplate) {
            const effectDesc = this.replaceVariables(template.effectTemplate, skill, caster);
            description += ` ${effectDesc}`;
        }

        // 添加冷却信息
        if (template.cooldownTemplate && skill.cooldown > 0) {
            const cooldownDesc = this.replaceVariables(template.cooldownTemplate, skill, caster);
            description += ` ${cooldownDesc}`;
        }

        return description;
    }

    /**
     * 生成默认描述
     * @param skill 技能实例
     * @param caster 施法者（可选）
     * @returns 默认描述
     */
    private generateDefaultDescription(skill: ISkill, caster?: IBattleParticipant): string {
        let description = skill.description || skill.name;

        // 添加等级信息
        if (skill.level > 1) {
            description += ` (等级 ${skill.level})`;
        }

        // 添加永久提升信息
        const boosts: string[] = [];
        for (const [boostType, amount] of skill.permanentBoosts) {
            boosts.push(`${boostType} +${amount}`);
        }
        if (boosts.length > 0) {
            description += ` (${boosts.join(', ')})`;
        }

        // 添加效果信息
        const totalEffect = this.calculateTotalEffect(skill, caster);
        if (totalEffect > 0) {
            if (skill.type === SkillType.主动技能) {
                description += ` (伤害 ${totalEffect})`;
            } else {
                description += ` (效果 ${totalEffect})`;
            }
        }

        return description;
    }

    /**
     * 替换描述中的变量
     * @param description 原始描述
     * @param skill 技能实例
     * @param caster 施法者（可选）
     * @returns 替换后的描述
     */
    private replaceVariables(description: string, skill: ISkill, caster?: IBattleParticipant): string {
        let result = description;

        for (const [variable, resolver] of this.variableResolvers) {
            if (result.includes(variable)) {
                const value = resolver(skill, caster);
                result = result.replace(new RegExp(variable.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), String(value));
            }
        }

        return result;
    }

    /**
     * 计算基础效果
     * @param skill 技能实例
     * @param caster 施法者（可选）
     * @returns 基础效果值
     */
    private calculateBaseEffect(skill: ISkill, caster?: IBattleParticipant): number {
        // 基础效果计算逻辑
        let baseEffect = 10;
        
        if (caster) {
            const attack = caster.getAttribute('attack' as any) || 0;
            baseEffect += attack * 0.5;
        }
        
        return Math.max(0, baseEffect);
    }

    /**
     * 计算等级效果
     * @param skill 技能实例
     * @param caster 施法者（可选）
     * @returns 等级效果值
     */
    private calculateLevelEffect(skill: ISkill, caster?: IBattleParticipant): number {
        const baseEffect = this.calculateBaseEffect(skill, caster);
        const levelMultiplier = 1 + (skill.level - 1) * 0.1;
        return Math.floor(baseEffect * levelMultiplier);
    }

    /**
     * 计算总效果
     * @param skill 技能实例
     * @param caster 施法者（可选）
     * @returns 总效果值
     */
    private calculateTotalEffect(skill: ISkill, caster?: IBattleParticipant): number {
        let totalEffect = this.calculateLevelEffect(skill, caster);
        
        // 添加永久提升
        for (const [boostType, amount] of skill.permanentBoosts) {
            if (boostType === 'damage' || boostType === 'effect') {
                totalEffect += amount;
            }
        }
        
        return Math.max(0, totalEffect);
    }

    /**
     * 更新技能描述
     * @param skill 技能实例
     * @param caster 施法者（可选）
     */
    public updateSkillDescription(skill: ISkill, caster?: IBattleParticipant): void {
        const newDescription = this.generateDescription(skill, caster);
        
        // 这里需要更新技能的描述
        // 由于ISkill接口可能没有setDescription方法，我们需要通过其他方式更新
        // 暂时记录日志
        BattleLogger.log('info', '技能描述已更新', {
            skillId: skill.id,
            skillName: skill.name,
            oldDescription: skill.description,
            newDescription
        });
    }

    /**
     * 获取技能描述模板
     * @param skillId 技能ID
     * @returns 描述模板或null
     */
    public getDescriptionTemplate(skillId: string): ISkillDescriptionTemplate | null {
        return this.descriptionTemplates.get(skillId) || null;
    }

    /**
     * 验证描述模板
     * @param template 描述模板
     * @returns 是否有效
     */
    public validateDescriptionTemplate(template: ISkillDescriptionTemplate): boolean {
        if (!template.baseDescription) {
            return false;
        }
        
        // 检查变量是否有效
        const allVariables = [
            template.baseDescription,
            template.levelTemplate,
            template.permanentBoostTemplate,
            template.effectTemplate,
            template.cooldownTemplate
        ].filter(Boolean).join(' ');
        
        for (const variable of this.variableResolvers.keys()) {
            if (allVariables.includes(variable)) {
                // 变量存在，继续检查
            }
        }
        
        return true;
    }

    /**
     * 获取所有可用的变量
     * @returns 变量列表
     */
    public getAvailableVariables(): string[] {
        return Array.from(this.variableResolvers.keys());
    }

    /**
     * 创建标准描述模板
     * @param skillType 技能类型
     * @returns 标准模板
     */
    public createStandardTemplate(skillType: SkillType): ISkillDescriptionTemplate {
        switch (skillType) {
            case SkillType.主动技能:
                return {
                    baseDescription: '对目标造成{totalEffect}点伤害',
                    levelTemplate: '(等级{level})',
                    permanentBoostTemplate: '(永久提升: {permanentBoosts})',
                    effectTemplate: '(基础伤害{baseEffect}, 等级加成{levelEffect})',
                    cooldownTemplate: '(冷却{cooldown}回合)'
                };
                
            case SkillType.被动技能:
                return {
                    baseDescription: '被动效果: {totalEffect}',
                    levelTemplate: '(等级{level})',
                    permanentBoostTemplate: '(永久提升: {permanentBoosts})',
                    effectTemplate: '(基础效果{baseEffect}, 等级加成{levelEffect})'
                };
                
            case SkillType.光环技能:
                return {
                    baseDescription: '光环效果: {totalEffect}',
                    levelTemplate: '(等级{level})',
                    permanentBoostTemplate: '(永久提升: {permanentBoosts})',
                    effectTemplate: '(基础效果{baseEffect}, 等级加成{levelEffect})'
                };
                
            default:
                return {
                    baseDescription: '技能效果: {totalEffect}',
                    levelTemplate: '(等级{level})',
                    permanentBoostTemplate: '(永久提升: {permanentBoosts})'
                };
        }
    }
}

// 导出单例实例
export const skillDescriptionManager = new SkillDescriptionManager(); 